﻿#include "mythread.h"

#include "mainwindow.h"
#pragma execution_character_set("utf-8")



MyThread::MyThread()
{
    isStop = false;
    TemplateStart = false;
    for(int i=0;i<4;i++)
    {
        Pcount[i].release();
    }
    match_method = 1;//匹配模式选择

    // rows cols 480*640  354*490
    result.create(151,127,CV_8U);

}

void MyThread::closeThread()
{
    isStop = true;
    TemplateStart =false;
}

//模板匹配设置
void MyThread::SetTemplate(bool startsignal,Mat &src, int mode)
{
    TemplateStart =startsignal;
    match_method = mode;
    thTemplateImage = src;
}


// 图像校正
void MyThread::MatCcorrection(Mat &src,Mat& outputImg)
{
    Mat orgImg,cannyImg,grayImg,thresholdImg,turnedImg,gaussImg;
    orgImg    = src.clone();

    turnedImg = src.clone();

    //灰度图
    cvtColor(orgImg,grayImg,cv::COLOR_BGR2GRAY);

    //高斯模糊
    GaussianBlur(grayImg,gaussImg,Size(3,3),1.5);

    //二值化
    threshold(grayImg,thresholdImg,120,255,THRESH_BINARY_INV);

    //开运算 白色区域先腐蚀后膨胀
    Mat element = getStructuringElement(MORPH_RECT,Size(3,3));
    morphologyEx(thresholdImg,thresholdImg,MORPH_OPEN,element);

    //腐蚀 分离小数点
    Mat element1 = getStructuringElement(MORPH_RECT,Size(5,5));
    erode(thresholdImg,thresholdImg,element1);

    imshow("thresholdImg",thresholdImg);

    //边缘检测
    Canny(thresholdImg,cannyImg,50,200,3);

    //提取最大轮廓
    vector<vector<Point>> contours;    //储存轮廓
    vector<Vec4i> hierarchy;
    findContours(cannyImg, contours, hierarchy,
                 RETR_CCOMP, CHAIN_APPROX_SIMPLE);    //获取轮廓

    if(contours.size() < 1)
    {
        qDebug()<<"未发现轮廓";
        return;
    }

    //提取最大面积轮廓 矩形包围
    vector<vector<Point>> polyContours(contours.size());

    int maxArea = 0;
    for (int index = 0; index < contours.size(); index++){
        if (contourArea(contours[index]) > contourArea(contours[maxArea]))
            maxArea = index;
        //多边形逼近
        approxPolyDP(contours[index], polyContours[index], 100, true);
    }

    //过滤掉面积gauss小的轮廓
    if(contourArea(contours[maxArea]) <= 28000)     //28000
    {
        qDebug()<<"未检测到合适面积"<<contourArea(contours[maxArea]);
        return;
    }

    //画出矩形
    drawContours(orgImg, polyContours, maxArea, Scalar(0,0,255), 2);

    //凸包检测 获取矩形四个点
    vector<int>  hull;
    convexHull(polyContours[maxArea], hull, false);    //检测该轮廓的凸包

    if(hull.size() != 4)
    {
        qDebug()<<"检测到非矩形的点";
        return;
    }

    //画出点
    for (int i = 0; i < hull.size(); ++i){
        circle(orgImg, polyContours[maxArea][i], 10, Scalar(255, 0, 0), 3);
    }
    imshow("juxing img",orgImg);

    //目标坐标
    Point2f srcPoints[4], dstPoints[4]; //左上，右上，右下， 左下
    dstPoints[0] = Point2f(-30, 0);
    dstPoints[1] = Point2f(5*62, 0);
    dstPoints[2] = Point2f(5*62, 7*34);
    dstPoints[3] = Point2f(-30, 7*34);

    //对四个点进行排序 分出左上 右上 右下 左下
    bool sorted = false;
    int n = 4;
    while (!sorted){
        for (int i = 1; i < n; i++){
            sorted = true;
            if (polyContours[maxArea][i-1].x > polyContours[maxArea][i].x){
                swap(polyContours[maxArea][i-1], polyContours[maxArea][i]);
                sorted = false;
            }
        }
        n--;
    }

    if (polyContours[maxArea][0].y < polyContours[maxArea][1].y){
        srcPoints[0] = polyContours[maxArea][0];
        srcPoints[3] = polyContours[maxArea][1];
    }
    else{
        srcPoints[0] = polyContours[maxArea][1];
        srcPoints[3] = polyContours[maxArea][0];
    }

    if (polyContours[maxArea][2].y < polyContours[maxArea][3].y){
        srcPoints[1] = polyContours[maxArea][2];
        srcPoints[2] = polyContours[maxArea][3];
    }
    else{
        srcPoints[1] = polyContours[maxArea][3];
        srcPoints[2] = polyContours[maxArea][2];
    }


    //获取变换矩阵 坐标变换
    Mat transMat = getPerspectiveTransform(srcPoints,dstPoints);

    warpPerspective(thresholdImg , outputImg, transMat,
                    thresholdImg.size(),INTER_LINEAR// INTER_LINEAR | WARP_INVERSE_MAP
                    );
    imshow("outputImg",outputImg);

    Rect rect(outputImg.cols/10,outputImg.rows/10,
              9*outputImg.cols/10, 4*outputImg.rows/5);
    Mat outputImg1 = outputImg(rect);
    imshow("outputImg1",outputImg1);
    MatSegmentation(outputImg1);

}

//数字分割
void MyThread::MatSegmentation(Mat& inputsrc)
{
    Mat orgImg,thorgImg,cannyImg;

    int src_width  = inputsrc.cols;
    int src_height = inputsrc.rows;
    int* projectValArry = new int[src_width]();//创建用于储存每列白色像素个数的数组

    //取列白色像素个数
    for (int i = 0; i < src_height; i++){
        for (int j = 0; j < src_width; j++){
            if (inputsrc.at<uchar>(i, j)){
                projectValArry[j]++;
            }
        }
    }

    /**************将每列白色像素数目绘制成直方图***************************/
    //定义画布 绘制垂直投影下每列白色像素的数目
    Mat verticalProjectionMat(src_height, src_width, CV_8UC1, Scalar(0));
    for (int i = 0; i< src_width; i++){
        for (int j = 0; j < projectValArry[i]; j++){
            verticalProjectionMat.at<uchar>(src_height-j-1,i) = 255;
        }
    }
    imshow("verticalProjectionMat", verticalProjectionMat);


    /*********根据每列白色像素数目设置截取起始和截止列***********************/
    //定义Mat vector ，存储图片组
    vector<Mat> split_src;

    //定义标志，用来指示在白色像素区还是在全黑区域
    bool white_block = 0, black_block = 0;

    //定义列temp_col_forword  temp_col_behind，记录字符截取起始列和截止列
    int temp_col_forword=0,temp_col_behind = 0;

    Mat split_temp;
    //遍历数组projectValArry
    for (int i = 0; i < src_width; i++){
        if (projectValArry[i]){//表示区域有白色像素
            white_block = 1;
            black_block = 0;
        }
        else{				//若无白色像素（进入黑色区域）
            if (white_block == 1){//若前一列有白色像素
                temp_col_behind = i;//取当前列为截止列

                split_temp=inputsrc(Rect(temp_col_forword, 0, temp_col_behind - temp_col_forword, src_height)).clone();
                split_src.push_back(split_temp);
            }
            temp_col_forword = i;//记录最新黑色区域的列号，记为起始列
            black_block = 1;//表示进入黑色区域
            white_block = 0;
        }
    }

    qDebug()<<split_src.size();


    for (int i = 0; i < split_src.size(); i++){

        //sprintf(window, " split: %d", i);
        myDiscern(split_src[i]);
        imshow(QString::number(i).toStdString(), split_src[i]);
    }
}


//识别中间行的单个数字
void MyThread::myDiscern(Mat n)
{
    //1的图像，使用穿线会是8。应该从它的尺寸入手，高远大于宽，这里我们选取3倍比.
    if(3*n.cols<n.rows)
    {
        emit thSetNumber(1);
        qDebug()<<"数字：1";
        return;
    }
    //竖线
    int x_half=n.cols/2;
    //上横线
    int y_one_third=n.rows/3;
    //下横线
    int y_two_third=n.rows*2/3;
    //每段数码管，0灭，1亮
    int a=0,b=0,c=0,d=0,e=0,f=0,g=0;

    //竖线识别a,g,d段
    for(int i=0;i<n.rows;i++)
    {
        uchar *data=n.ptr<uchar>(i);
        if(i<y_one_third)
        {
            if(data[x_half]==255) a=1;
        }
        else if(i>y_one_third&&i<y_two_third)
        {
            if(data[x_half]==255) g=1;
        }
        else
        {
            if(data[x_half]==255) d=1;
        }
    }

    //上横线识别：
    for(int j=0;j<n.cols;j++)
    {
        uchar *data=n.ptr<uchar>(y_one_third);
        //f
        if(j<x_half)
        {
            if(data[j]==255) f=1;
        }
        //b
        else
        {
            if(data[j]==255) b=1;
        }
    }

    //下横线识别：
    for(int j=0;j<n.cols;j++)
    {
        uchar *data=n.ptr<uchar>(y_two_third);
        //e
        if(j<x_half)
        {
            if(data[j]==255) e=1;
        }
        //c
        else
        {
            if(data[j]==255) c=1;
        }
    }

    //七段管组成的数字
    if(a==1 && b==1 && c==1 && d==1 && e==1 && f==1 && g==0)
    {
        emit thSetNumber(0);
        qDebug()<<"数字：0";
        return;
    }
    else if(a==0 && b==1 && c==1 && d==0 && e==0 && f==0 && g==0)
    {
        emit thSetNumber(1);
        qDebug()<<"数字：1";
        return;
    }
    else if(a==1 && b==1 && c==0 && d==1 && e==1 && f==0 && g==1)
    {
        emit thSetNumber(2);
        qDebug()<<"数字：2";
        return;
    }
    else if(a==1 && b==1 && c==1 && d==1 && e==0 && f==0 && g==1)
    {
        emit thSetNumber(3);
        qDebug()<<"数字：3";
        return;
    }
    else if(a==0 && b==1 && c==1 && d==0 && e==0 && f==1 && g==1)
    {
        emit thSetNumber(4);
        qDebug()<<"数字：4";
        return;
    }
    else if(a==1 && b==0 && c==1 && d==1 && e==0 && f==1 && g==1)
    {
        emit thSetNumber(5);
        qDebug()<<"数字：5";
        return;
    }
    else if(a==1 && b==0 && c==1 && d==1 && e==1 && f==1 && g==1)
    {
        emit thSetNumber(6);
        qDebug()<<"数字：6";
        return;
    }
    else if(a==1 && b==1 && c==1 && d==0 && e==0 && f==0 && g==0)
    {
        emit thSetNumber(7);
        qDebug()<<"数字：7";
        return;
    }
    else if(a==1 && b==1 && c==1 && d==1 && e==1 && f==1 && g==1)
    {
        emit thSetNumber(8);
        qDebug()<<"数字：8";
        return;
    }
    else if(a==1 && b==1 && c==1 && d==1 && e==0 && f==1 && g==1)
    {
        emit thSetNumber(9);
        qDebug()<<"数字：9";
        return;
    }
    else
    {
        //printf("[error_%d_%d_%d_%d_%d_%d_%d]",a,b,c,d,e,f,g);
        return;
    }

}




/*Method
0: SQDIFF           平方差匹配
1: SQDIFF NORMED    标准平方差匹配
2: TM CCORR         相关匹配
3: TM CCORR NORMED  标准相关匹配
4: TM COEFF         相关匹配
5: TM COEFF NORMED" 标准相关匹配
对于方法 SQDIFF 和 SQDIFF_NORMED,
越小的数值代表更高的匹配结果. 而对于其他方法, 数值越大匹配越好*/

void MyThread::run()
{
    cv::VideoCapture capture(0);

    while (!capture.isOpened()) qDebug()<<"摄像头正在打开"<<endl;


    while (!isStop)
    {
        capture.read(frame);

        if(TemplateStart)
        {
            //开始匹配
            Mat originimg = frame.clone();
            cv::matchTemplate(originimg,thTemplateImage,result,match_method);
            cv::normalize(result,result,0,1,NORM_MINMAX,-1,Mat());  //归一化数据

            //取出最佳匹配结果
            double Val;
            double minVal,maxVal;
            Point  minLoc,maxLoc,matchLoc;
            minMaxLoc(result,&minVal,&maxVal,&minLoc,&maxLoc,Mat());
            if(match_method == 0 ||match_method == 1){

                matchLoc = minLoc;
                Val = minVal;
            }
            else {
                matchLoc = maxLoc;
                Val = maxVal;
            }

            //截取图像
            Rect rect(matchLoc.x,
                      matchLoc.y,
                      thTemplateImage.cols,
                      thTemplateImage.rows);

            Mat cutimg = frame(rect);

            Mat turnedimg;
            MatCcorrection(cutimg,turnedimg);

            ///////////////////////*****************************/////////////////////

            rectangle(frame,matchLoc,
                      Point(matchLoc.x+thTemplateImage.cols,
                            matchLoc.y+thTemplateImage.rows),
                      Scalar(255,0,0),2,8,0);
            //            cv::putText(frame,"maxval:"+QString::number(maxVal).toStdString(),
            //                        Point(matchLoc.x+thTemplateImage.cols -300,
            //                              matchLoc.y+thTemplateImage.rows-170),
            //                        cv::FONT_HERSHEY_PLAIN,3,Scalar(255,0,0),
            //                        3,8);
        }

        cv::waitKey(10);
        emit thShowImage(frame);

    }
}


